#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <ctype.h>
using namespace std;
const int basesize = 4096;
const int argvnum = 64;
const int envnum = 64;
// 全局的命令⾏参数表

char *gargv[argvnum];
int gargc = 0;
// 全局的变量

int lastcode = 0;
// 我的系统的环境变量

char *genv[envnum];
// 全局的当前shell⼯作路径

char pwd[basesize];
char pwdenv[basesize];

// "    "file.txt
#define TrimSpace(pos)        \
    do                        \
    {                         \
        while (isspace(*pos)) \
        {                     \
            pos++;            \
        }                     \
    } while (0)

string GetUserName()
{
    const char *name = getenv("USER");
    return (name == nullptr) ? "None" : string(name);
}

string GetHostName()
{
    const char *hostname = getenv("HOSTNAME");
    return (hostname == nullptr) ? "None" : string(hostname);
}
string GetPwd() {
    char path[basesize];
    if (getcwd(path, sizeof(path)) == nullptr) {
        perror("getcwd failed");
        return "None";
    }
    
    // 动态分配足够大的缓冲区
    char *env_str = new char[strlen(path) + 5];
    snprintf(env_str, strlen(path) + 5, "PWD=%s", path);
    
    putenv(env_str);
    // 注意：不要delete，putenv需要保持内存有效
    
    return path;
}
string LastDir() {
    string curr = GetPwd();
    if (curr == "/" || curr == "None")
        return curr;
    size_t pos = curr.rfind("/");
    if (pos == std::string::npos)
        return curr;
    return curr.substr(pos + 1);
}

string MakeCommandLine() {
    char command_line[basesize];
    snprintf(command_line, basesize, "[%s@%s %s]# ",
             GetUserName().c_str(), GetHostName().c_str(), LastDir().c_str());
    return command_line;
}

void PrintCommandLine() // 1. 命令⾏提⽰符
{

    printf("%s", MakeCommandLine().c_str());
    fflush(stdout);
}

bool GetCommandLine(char command_buffer[], int size) // 2. 获取⽤⼾命令
{
    // 我们认为：我们要将⽤⼾输⼊的命令⾏，当做⼀个完整的字符串
    // "ls -a -l -n"
    char *result = fgets(command_buffer, size, stdin);
    if (!result)
    {
        return false;
    }
    command_buffer[strlen(command_buffer) - 1] = 0;
    if (strlen(command_buffer) == 0)
        return false;
    return true;
}
void ParseCommandLine(char command_buffer[], int len) // 3. 分析命令
{
    (void)len;
    memset(gargv, 0, sizeof(gargv));
    gargc = 0;
    // "ls -a -l -n"
    const char *sep = " ";
    gargv[gargc++] = strtok(command_buffer, sep);
    // =是刻意写的

    while ((bool)(gargv[gargc++] = strtok(nullptr, sep)))
        ;
    gargc--;
}
void debug()
{
    printf("argc: %d\n", gargc);
    for (int i = 0; gargv[i]; i++)
    {
        printf("argv[%d]: %s\n", i, gargv[i]);
    }
}

bool ExecuteCommand() // 4. 执⾏命令

{
    // 让⼦进程进⾏执⾏

    pid_t id = fork();
    if (id < 0)
        return false;
    if (id == 0)
    {
        // ⼦进程

        // 1. 执⾏命令

        execvpe(gargv[0], gargv, genv);
        // 2. 退出

        exit(1);
    }

    int status = 0;
    pid_t rid = waitpid(id, &status, 0);
    if (rid > 0)
    {
        if (WIFEXITED(status))
        {
            lastcode = WEXITSTATUS(status);
        }
        else
        {
            lastcode = 100;
        }
        return true;
    }
    return false;
}

void AddEnv(const char *item)
{
    int index = 0;
    while (genv[index])
    {
        index++;
    }
    genv[index] = (char *)malloc(strlen(item) + 1);
    strncpy(genv[index], item, strlen(item) + 1);
    genv[++index] = nullptr;
}
// shell⾃⼰执⾏命令，本质是shell调⽤⾃⼰的函数

bool CheckAndExecBuiltCommand()
{
    if (strcmp(gargv[0], "cd") == 0)
    {
        // 内建命令

        if (gargc == 2)
        {
            chdir(gargv[1]);
            lastcode = 0;
        }
        else
        {
            lastcode = 1;
        }
        return true;
    }
    else if (strcmp(gargv[0], "export") == 0)
    {
        // export也是内建命令

        if (gargc == 2)
        {
            AddEnv(gargv[1]);
            lastcode = 0;
        }
        else
        {
            lastcode = 2;
        }
        return true;
    }
    else if (strcmp(gargv[0], "env") == 0)
    {
        for (int i = 0; genv[i]; i++)
        {
            printf("%s\n", genv[i]);
        }
        lastcode = 0;
        return true;
    }
    else if (strcmp(gargv[0], "echo") == 0)
    {
        if (gargc == 2)
        {
            // echo $?
            // echo $PATH
            // echo hello
            if (gargv[1][0] == '$')
            {
                if (gargv[1][1] == '?')
                {
                    printf("%d\n", lastcode);
                    lastcode = 0;
                }
            }
            else
            {
                printf("%s\n", gargv[1]);
                lastcode = 0;
            }
        }
        else
        {
            lastcode = 3;
        }
        return true;
    }
    return false;
}
void InitEnv()
{
    extern char **environ;
    int index = 0;
    while (environ[index])
    {
        genv[index] = (char *)malloc(strlen(environ[index]) + 1);
        strncpy(genv[index], environ[index], strlen(environ[index]) + 1);
        index++;
    }
    genv[index] = nullptr;
}
int main()
{
    InitEnv();
    char command_buffer[basesize];
    while (true)
    {
        PrintCommandLine(); // 1. 命令⾏提⽰符
        // command_buffer -> output
        if (!GetCommandLine(command_buffer, basesize)) // 2. 获取⽤⼾命令
        {
            continue;
        } // printf("%s\n", command_buffer);
        ParseCommandLine(command_buffer, strlen(command_buffer)); // 3. 分析命令
        if (CheckAndExecBuiltCommand())
        {
            continue;
        }
        ExecuteCommand(); // 4. 执⾏命令
    }
    return 0;
}